```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>MySQL 索引优化指南 - 规避失效陷阱</title>
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        :root {
            --primary: #2563eb;
            --primary-dark: #1d4ed8;
            --secondary: #7c3aed;
            --accent: #f59e0b;
            --dark: #1e293b;
            --light: #f8fafc;
        }
        
        body {
            font-family: 'Noto Sans SC', 'Noto Serif SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            line-height: 1.8;
            color: #334155;
            background-color: #f8fafc;
        }
        
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: var(--dark);
        }
        
        .hero {
            background: linear-gradient(135deg, #2563eb 0%, #7c3aed 100%);
            color: white;
        }
        
        .card {
            transition: all 0.3s ease;
            border-radius: 12px;
            overflow: hidden;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
        }
        
        .card:hover {
            transform: translateY(-4px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        
        .badge {
            display: inline-flex;
            align-items: center;
            padding: 0.25rem 0.75rem;
            border-radius: 9999px;
            font-size: 0.75rem;
            font-weight: 600;
            text-transform: uppercase;
            letter-spacing: 0.05em;
        }
        
        .divider {
            height: 1px;
            background: linear-gradient(90deg, transparent, rgba(0,0,0,0.1), transparent);
            margin: 2rem 0;
        }
        
        .solution-card {
            border-left: 4px solid var(--primary);
        }
        
        .solution-card:hover {
            border-left: 4px solid var(--accent);
        }
        
        .mermaid-container {
            background-color: white;
            border-radius: 12px;
            padding: 1.5rem;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
            margin: 2rem 0;
        }
        
        code {
            font-family: 'Courier New', Courier, monospace;
            background-color: #f1f5f9;
            padding: 0.2rem 0.4rem;
            border-radius: 4px;
            color: #334155;
            font-size: 0.9em;
        }
        
        pre {
            background-color: #1e293b;
            color: #f8fafc;
            padding: 1rem;
            border-radius: 8px;
            overflow-x: auto;
            margin: 1rem 0;
            font-family: 'Courier New', Courier, monospace;
        }
        
        pre code {
            background-color: transparent;
            color: inherit;
            padding: 0;
            border-radius: 0;
        }
        
        .sql-keyword {
            color: #60a5fa;
        }
        
        .sql-string {
            color: #86efac;
        }
        
        .sql-comment {
            color: #94a3b8;
        }
        
        .sql-function {
            color: #fca5a5;
        }
        
        .sql-number {
            color: #f59e0b;
        }
    </style>
</head>
<body>
    <!-- Hero Section -->
    <section class="hero py-16 md:py-24 px-4 md:px-0">
        <div class="container mx-auto max-w-4xl text-center">
            <div class="inline-block px-4 py-1 bg-white bg-opacity-20 rounded-full mb-4">
                <span class="text-sm font-semibold tracking-wider">数据库优化系列</span>
            </div>
            <h1 class="text-3xl md:text-5xl font-bold mb-6">MySQL 索引失效的原因及解决方案</h1>
            <p class="text-xl md:text-2xl opacity-90 mb-8 max-w-3xl mx-auto">深入剖析索引失效场景，掌握高效查询的黄金法则</p>
            <div class="flex justify-center space-x-4">
                <a href="#reasons" class="px-6 py-3 bg-white text-blue-700 font-semibold rounded-lg hover:bg-opacity-90 transition-all">
                    <i class="fas fa-search mr-2"></i>索引失效原因
                </a>
                <a href="#solutions" class="px-6 py-3 border-2 border-white text-white font-semibold rounded-lg hover:bg-white hover:bg-opacity-20 transition-all">
                    <i class="fas fa-lightbulb mr-2"></i>解决方案
                </a>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="container mx-auto max-w-4xl px-4 md:px-0 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <div class="prose max-w-none">
                <p class="text-lg leading-relaxed mb-6">
                    在我们使用 MySQL 数据库进行开发时，性能优化往往是一个关键的关注点，而索引的使用对于提高查询效率至关重要。索引能够帮助数据库快速定位数据，从而避免全表扫描。然而，索引并非在所有情况下都能发挥作用，有时我们可能会遇到"索引失效"的问题。这不仅会导致查询性能下降，还可能影响整体系统的响应速度。
                </p>
                
                <div class="my-8">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1733982358034-5ec71d5c-b079-4f1f-bd29-1bfc064eb4a8.png" alt="MySQL索引示意图" class="rounded-xl shadow-lg w-full object-cover">
                    <p class="text-center text-sm text-gray-500 mt-2">MySQL索引工作原理示意图</p>
                </div>
                
                <p class="text-lg leading-relaxed mb-6">
                    常见的索引失效原因包括查询条件中的隐式类型转换、函数使用、OR 操作符等，我们还会讨论如何通过合理的索引设计来避免这些问题的发生。此外，我们还将探讨在实际项目中如何通过分析执行计划、优化查询语句和调整索引结构来确保索引的有效使用。通过这些优化策略，能够显著提高数据库的查询性能，保证系统在高并发和大数据量环境下的稳定性和高效性。
                </p>
            </div>
        </section>

        <!-- Index Definition -->
        <section id="definition" class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="w-8 h-8 bg-blue-100 text-blue-700 rounded-full flex items-center justify-center mr-3">1</span>
                索引失效的定义
            </h2>
            
            <div class="prose max-w-none">
                <p class="mb-6">
                    在 MySQL 中，索引失效指的是查询操作没有正确地利用到数据库表中的索引，而是选择了其他查询路径（通常是全表扫描），从而导致性能下降。虽然表中存在索引，但由于某些原因，查询优化器未能使用索引进行高效的查询操作，而是执行全表扫描或其他不高效的执行方式。索引失效通常会显著增加查询的响应时间，尤其是在数据量较大的表中，因为全表扫描需要遍历所有数据记录，而索引则可以大幅度减少数据的扫描范围。
                </p>
                
                <div class="my-8">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1733982624135-031aaefa-dffb-480a-91cb-68350255ac54.png" alt="索引失效示意图" class="rounded-xl shadow-lg w-full object-cover">
                    <p class="text-center text-sm text-gray-500 mt-2">索引失效与有效索引的对比</p>
                </div>
                
                <div class="bg-blue-50 border-l-4 border-blue-500 p-4 rounded-r-lg mb-8">
                    <h3 class="font-semibold text-blue-800 mb-2">索引失效的常见原因</h3>
                    <ul class="list-disc pl-5 space-y-2">
                        <li><strong>类型转换</strong>：查询条件中的数据类型不匹配，导致 MySQL 无法使用索引。</li>
                        <li><strong>函数操作</strong>：在查询条件中对索引列应用了函数，导致索引无法被有效使用。</li>
                        <li><strong>OR 操作符</strong>：在查询条件中使用 <code>OR</code> 时，如果其中一个条件不能使用索引，可能导致索引失效。</li>
                        <li><strong>不适当的复合索引使用</strong>：对于复合索引，如果查询中不使用索引的前缀字段，或者使用了范围查询，索引可能无法被有效利用。</li>
                        <li><strong>NULL 值的比较</strong>：查询条件中如果涉及到 <code>NULL</code> 值的比较，可能会导致索引失效。</li>
                        <li><strong>数据范围查询</strong>：对索引字段进行范围查询（如 <code>BETWEEN</code>、<code>&gt;、&lt;</code> 等）时，索引的使用可能不如预期。</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Reasons Section -->
        <section id="reasons" class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <span class="w-8 h-8 bg-red-100 text-red-700 rounded-full flex items-center justify-center mr-3">2</span>
                索引失效的常见原因
            </h2>
            
            <p class="text-lg mb-8">
                在 MySQL 中，索引失效是指查询操作未能正确地使用数据库表中的索引，而是转而使用全表扫描或其他不高效的查询方式。
            </p>
            
            <!-- Reason Cards -->
            <div class="grid md:grid-cols-2 gap-6">
                <!-- Reason 1 -->
                <div class="card bg-white p-6">
                    <div class="flex items-center mb-4">
                        <div class="w-10 h-10 bg-red-100 text-red-700 rounded-full flex items-center justify-center mr-4">
                            <i class="fas fa-exchange-alt"></i>
                        </div>
                        <h3 class="text-xl font-bold">数据类型不匹配</h3>
                    </div>
                    <p class="mb-4">
                        当查询条件中的数据类型与索引字段的数据类型不一致时，MySQL 可能无法使用索引。这种情况通常发生在查询条件中使用了隐式类型转换，导致 MySQL 不能利用索引进行高效查询。
                    </p>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <pre><code class="sql"><span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> id = <span class="sql-string">'123'</span>;  <span class="sql-comment">-- id是整数类型，'123'是字符串类型</span></code></pre>
                    </div>
                    <p class="mt-4 text-sm text-gray-600">
                        此时，MySQL 会把字符串 <code>'123'</code> 转换为整数进行查询，但如果转换失败，可能会导致索引失效。
                    </p>
                </div>
                
                <!-- Reason 2 -->
                <div class="card bg-white p-6">
                    <div class="flex items-center mb-4">
                        <div class="w-10 h-10 bg-yellow-100 text-yellow-700 rounded-full flex items-center justify-center mr-4">
                            <i class="fas fa-function"></i>
                        </div>
                        <h3 class="text-xl font-bold">对索引列应用了函数</h3>
                    </div>
                    <p class="mb-4">
                        在查询条件中对索引字段使用了函数时，索引会失效。因为函数的应用会改变索引字段的值，使得数据库无法直接利用索引来快速定位记录。
                    </p>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <pre><code class="sql"><span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> <span class="sql-function">YEAR</span>(birthday) = <span class="sql-number">1990</span>;  <span class="sql-comment">-- 对birthday字段应用了YEAR()函数</span></code></pre>
                    </div>
                    <p class="mt-4 text-sm text-gray-600">
                        在这种情况下，由于对 <code>birthday</code> 字段应用了函数，MySQL 无法利用该字段的索引进行查询。
                    </p>
                </div>
                
                <!-- Reason 3 -->
                <div class="card bg-white p-6">
                    <div class="flex items-center mb-4">
                        <div class="w-10 h-10 bg-purple-100 text-purple-700 rounded-full flex items-center justify-center mr-4">
                            <i class="fas fa-link"></i>
                        </div>
                        <h3 class="text-xl font-bold">使用 OR 连接多个条件</h3>
                    </div>
                    <p class="mb-4">
                        在查询条件中使用 <code>OR</code> 连接时，尤其是当其中一个条件无法使用索引时，可能导致索引失效。MySQL 会选择全表扫描，而不是使用索引，尽管其他条件可以利用索引。
                    </p>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <pre><code class="sql"><span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> id = <span class="sql-number">1</span> <span class="sql-keyword">OR</span> name = <span class="sql-string">'Alice'</span>;</code></pre>
                    </div>
                    <p class="mt-4 text-sm text-gray-600">
                        如果 <code>id</code> 列有索引，而 <code>name</code> 列没有索引，MySQL 可能会选择全表扫描，因为 <code>OR</code> 操作符使得优化器无法使用索引来处理两个条件。
                    </p>
                </div>
                
                <!-- Reason 4 -->
                <div class="card bg-white p-6">
                    <div class="flex items-center mb-4">
                        <div class="w-10 h-10 bg-green-100 text-green-700 rounded-full flex items-center justify-center mr-4">
                            <i class="fas fa-search"></i>
                        </div>
                        <h3 class="text-xl font-bold">使用了 LIKE 操作符</h3>
                    </div>
                    <p class="mb-4">
                        使用 <code>LIKE</code> 操作符时，如果匹配模式以通配符 <code>%</code> 开头（例如 <code>%abc</code>），则无法使用索引进行高效查询。虽然 <code>LIKE 'abc%'</code> 可以利用索引，但 <code>LIKE '%abc%'</code> 会导致索引失效，MySQL 会转为全表扫描。
                    </p>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <pre><code class="sql"><span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> name <span class="sql-keyword">LIKE</span> <span class="sql-string">'%abc'</span>;  <span class="sql-comment">-- 无法利用索引</span></code></pre>
                    </div>
                </div>
                
                <!-- Reason 5 -->
                <div class="card bg-white p-6">
                    <div class="flex items-center mb-4">
                        <div class="w-10 h-10 bg-indigo-100 text-indigo-700 rounded-full flex items-center justify-center mr-4">
                            <i class="fas fa-arrows-alt-h"></i>
                        </div>
                        <h3 class="text-xl font-bold">范围查询</h3>
                    </div>
                    <p class="mb-4">
                        当查询条件中有范围操作符（如 <code>BETWEEN</code>、<code>&gt;、&lt;</code> 等）时，复合索引的使用可能会出现问题，导致索引失效。特别是如果范围查询出现在复合索引的后续列上，MySQL 可能不能完全利用复合索引。
                    </p>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <pre><code class="sql"><span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> id &gt; <span class="sql-number">100</span> <span class="sql-keyword">AND</span> name = <span class="sql-string">'Alice'</span>;  <span class="sql-comment">-- id > 100 是范围查询，name没有作为前缀</span></code></pre>
                    </div>
                    <p class="mt-4 text-sm text-gray-600">
                        在这种情况下，复合索引的优化可能不如预期，因为范围查询出现在了复合索引的前缀列之外。
                    </p>
                </div>
                
                <!-- Reason 6 -->
                <div class="card bg-white p-6">
                    <div class="flex items-center mb-4">
                        <div class="w-10 h-10 bg-pink-100 text-pink-700 rounded-full flex items-center justify-center mr-4">
                            <i class="fas fa-question-circle"></i>
                        </div>
                        <h3 class="text-xl font-bold">NULL 值的比较</h3>
                    </div>
                    <p class="mb-4">
                        在查询中，如果对包含 <code>NULL</code> 值的索引字段进行比较（如 <code>IS NULL</code> 或 <code>IS NOT NULL</code>），MySQL 可能无法有效使用该字段的索引。<code>NULL</code> 的特殊性质使得索引的使用受到限制。
                    </p>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <pre><code class="sql"><span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> name <span class="sql-keyword">IS</span> <span class="sql-keyword">NULL</span>;</code></pre>
                    </div>
                </div>
            </div>
        </section>

        <!-- Visualization -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="w-8 h-8 bg-purple-100 text-purple-700 rounded-full flex items-center justify-center mr-3">3</span>
                索引失效原因关系图
            </h2>
            
            <div class="mermaid-container">
                <div class="mermaid">
                    graph TD
                        A[索引失效] --> B[数据类型不匹配]
                        A --> C[函数操作]
                        A --> D[OR操作符]
                        A --> E[LIKE通配符开头]
                        A --> F[范围查询]
                        A --> G[NULL值比较]
                        A --> H[索引列更新频繁]
                        
                        B --> I[隐式类型转换]
                        C --> J[字段值被函数改变]
                        D --> K[任一条件无索引]
                        E --> L[无法使用前缀索引]
                        F --> M[复合索引前缀失效]
                        G --> N[NULL值特殊处理]
                </div>
            </div>
        </section>

        <!-- Solutions Section -->
        <section id="solutions" class="mb-16">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <span class="w-8 h-8 bg-green-100 text-green-700 rounded-full flex items-center justify-center mr-3">4</span>
                解决方案
            </h2>
            
            <p class="text-lg mb-8">
                针对索引失效的各种情况，我们可以采取以下优化策略来确保索引的有效使用，提高查询性能。
            </p>
            
            <div class="space-y-6">
                <!-- Solution 1 -->
                <div class="solution-card bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="text-xl font-bold mb-4 flex items-center">
                        <span class="w-6 h-6 bg-blue-100 text-blue-700 rounded-full flex items-center justify-center mr-3">1</span>
                        确保数据类型匹配
                    </h3>
                    <p class="mb-4">
                        确保查询条件中的值类型与索引列的数据类型一致，避免发生隐式类型转换。
                    </p>
                    <div class="bg-blue-50 p-4 rounded-lg">
                        <h4 class="font-semibold text-blue-800 mb-2">解决方法：</h4>
                        <ul class="list-disc pl-5 space-y-1 mb-4">
                            <li>查询时明确指定与字段类型一致的值。</li>
                        </ul>
                        
                        <h4 class="font-semibold text-blue-800 mb-2">示例：</h4>
                        <div class="bg-gray-800 p-4 rounded-lg">
                            <pre><code class="sql"><span class="sql-comment">-- 假设 id 是整数类型</span>
<span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> id = <span class="sql-number">123</span>;  <span class="sql-comment">-- 避免使用 '123' 这样的字符串</span></code></pre>
                        </div>
                    </div>
                </div>
                
                <!-- Solution 2 -->
                <div class="solution-card bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="text-xl font-bold mb-4 flex items-center">
                        <span class="w-6 h-6 bg-yellow-100 text-yellow-700 rounded-full flex items-center justify-center mr-3">2</span>
                        避免对索引列使用函数或表达式
                    </h3>
                    <p class="mb-4">
                        不要在查询条件中对索引列使用函数或表达式，因为这会使 MySQL 无法直接利用索引。
                    </p>
                    <div class="bg-blue-50 p-4 rounded-lg">
                        <h4 class="font-semibold text-blue-800 mb-2">解决方法：</h4>
                        <ul class="list-disc pl-5 space-y-1 mb-4">
                            <li>将计算逻辑放在查询条件外部，或通过字段预处理避免运行时计算。</li>
                        </ul>
                        
                        <h4 class="font-semibold text-blue-800 mb-2">示例：</h4>
                        <div class="bg-gray-800 p-4 rounded-lg">
                            <pre><code class="sql"><span class="sql-comment">-- 错误示例：对 birthday 应用函数</span>
<span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> <span class="sql-function">YEAR</span>(birthday) = <span class="sql-number">1990</span>;

<span class="sql-comment">-- 修正后</span>
<span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> birthday <span class="sql-keyword">BETWEEN</span> <span class="sql-string">'1990-01-01'</span> <span class="sql-keyword">AND</span> <span class="sql-string">'1990-12-31'</span>;</code></pre>
                        </div>
                    </div>
                </div>
                
                <!-- Solution 3 -->
                <div class="solution-card bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="text-xl font-bold mb-4 flex items-center">
                        <span class="w-6 h-6 bg-purple-100 text-purple-700 rounded-full flex items-center justify-center mr-3">3</span>
                        优化 OR 查询
                    </h3>
                    <p class="mb-4">
                        <code>OR</code> 条件会导致索引失效，尤其是当某些条件没有索引时。可以通过重写查询或使用 <code>UNION</code> 来优化。
                    </p>
                    <div class="bg-blue-50 p-4 rounded-lg">
                        <h4 class="font-semibold text-blue-800 mb-2">解决方法：</h4>
                        <ul class="list-disc pl-5 space-y-1 mb-4">
                            <li>将 <code>OR</code> 条件拆分为多个查询，并通过 <code>UNION</code> 合并结果。</li>
                        </ul>
                        
                        <h4 class="font-semibold text-blue-800 mb-2">示例：</h4>
                        <div class="bg-gray-800 p-4 rounded-lg">
                            <pre><code class="sql"><span class="sql-comment">-- 原始查询</span>
<span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> id = <span class="sql-number">1</span> <span class="sql-keyword">OR</span> name = <span class="sql-string">'Alice'</span>;

<span class="sql-comment">-- 优化后</span>
<span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> id = <span class="sql-number">1</span>
<span class="sql-keyword">UNION</span>
<span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> name = <span class="sql-string">'Alice'</span>;</code></pre>
                        </div>
                    </div>
                </div>
                
                <!-- Solution 4 -->
                <div class="solution-card bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="text-xl font-bold mb-4 flex items-center">
                        <span class="w-6 h-6 bg-green-100 text-green-700 rounded-full flex items-center justify-center mr-3">4</span>
                        合理使用 LIKE
                    </h3>
                    <p class="mb-4">
                        对于 <code>LIKE</code> 查询，尽量避免使用通配符 <code>%</code> 开头的模式。
                    </p>
                    <div class="bg-blue-50 p-4 rounded-lg">
                        <h4 class="font-semibold text-blue-800 mb-2">解决方法：</h4>
                        <ul class="list-disc pl-5 space-y-1 mb-4">
                            <li>如果需要模糊查询，可以通过索引前缀匹配优化，例如 <code>LIKE 'abc%'</code>。</li>
                            <li>对于全文检索，考虑使用 MySQL 的全文索引。</li>
                        </ul>
                        
                        <h4 class="font-semibold text-blue-800 mb-2">示例：</h4>
                        <div class="bg-gray-800 p-4 rounded-lg">
                            <pre><code class="sql"><span class="sql-comment">-- 错误示例</span>
<span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> name <span class="sql-keyword">LIKE</span> <span class="sql-string">'%abc'</span>;

<span class="sql-comment">-- 优化后</span>
<span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> name <span class="sql-keyword">LIKE</span> <span class="sql-string">'abc%'</span>;</code></pre>
                        </div>
                    </div>
                </div>
                
                <!-- Solution 5 -->
                <div class="solution-card bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="text-xl font-bold mb-4 flex items-center">
                        <span class="w-6 h-6 bg-indigo-100 text-indigo-700 rounded-full flex items-center justify-center mr-3">5</span>
                        优化范围查询
                    </h3>
                    <p class="mb-4">
                        当范围查询（如 <code>BETWEEN</code>、<code>&gt;</code>、<code>&lt;</code> 等）出现在复合索引中时，确保范围列尽量靠后，以便 MySQL 能更有效利用前缀列的索引。
                    </p>
                    <div class="bg-blue-50 p-4 rounded-lg">
                        <h4 class="font-semibold text-blue-800 mb-2">解决方法：</h4>
                        <ul class="list-disc pl-5 space-y-1 mb-4">
                            <li>调整复合索引的列顺序，让范围条件列靠后。</li>
                        </ul>
                        
                        <h4 class="font-semibold text-blue-800 mb-2">示例：</h4>
                        <div class="bg-gray-800 p-4 rounded-lg">
                            <pre><code class="sql"><span class="sql-comment">-- 假设有复合索引 (id, name)</span>
<span class="sql-keyword">SELECT</span> * <span class="sql-keyword">FROM</span> users <span class="sql-keyword">WHERE</span> id &gt; <span class="sql-number">100</span> <span class="sql-keyword">AND</span> name = <span class="sql-string">'Alice'</span>;

<span class="sql-comment">-- 如果查询中常用 name 精确匹配，可以调整为索引 (name, id)</span></code></pre>
                        </div>
                    </div>
                </div>
                
                <!-- Solution 10 -->
                <div class="solution-card bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="text-xl font-bold mb-4 flex items-center">
                        <span class="w-6 h-6 bg-pink-100 text-pink-700 rounded-full flex items-center justify-center mr-3">10</span>
                        合理设置索引
                    </h3>
                    <p class="mb-4">
                        了解表中数据分布，避免为低选择性（如性别、状态等只有少量值的字段）创建索引。
                    </p>
                    <div class="bg-blue-50 p-4 rounded-lg">
                        <h4 class="font-semibold text-blue-800 mb-2">解决方法：</h4>
                        <ul class="list-disc pl-5 space-y-1 mb-4">
                            <li>对高选择性字段（唯一性较高的列）创建索引。</li>
                            <li>针对组合查询，创建复合索引。</li>
                        </ul>
                        
                        <h4 class="font-semibold text-blue-800 mb-2">示例：</h4>
                        <div class="bg-gray-800 p-4 rounded-lg">
                            <pre><code class="sql"><span class="sql-comment">-- 对高选择性字段（如 email）创建单列索引</span>
<span class="sql-keyword">CREATE</span> <span class="sql-keyword">INDEX</span> idx_email <span class="sql-keyword">ON</span> users(email);

<span class="sql-comment">-- 针对多字段查询，创建复合索引</span>
<span class="sql-keyword">CREATE</span> <span class="sql-keyword">INDEX</span> idx_multi <span class="sql-keyword">ON</span> users(first_name, last_name);</code></pre>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Summary -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="w-8 h-8 bg-blue-100 text-blue-700 rounded-full flex items-center justify-center mr-3">5</span>
                总结
            </h2>
            
            <div class="prose max-w-none">
                <p class="mb-6">
                    索引是 MySQL 性能优化的关键工具，但不当的使用会导致索引失效，反而影响查询性能。通过理解索引失效的各种场景，并采用相应的优化策略，可以显著提升数据库查询效率。
                </p>
                
                <div class="bg-gray-50 border-l-4 border-gray-500 p-4 rounded-r-lg mb-8">
                    <h3 class="font-semibold text-gray-800 mb-2">关键要点：</h3>
                    <ul class="list-disc pl-5 space-y-2">
                        <li>确保查询条件与索引字段类型匹配，避免隐式类型转换</li>
                        <li>避免在索引列上使用函数或表达式</li>
                        <li>优化 <code>OR</code> 查询，必要时使用 <code>UNION</code></li>
                        <li>合理使用 <code>LIKE</code>，避免前导通配符</li>
                        <li>优化复合索引的列顺序，特别是涉及范围查询时</li>
                        <li>定期使用 <code>EXPLAIN</code> 分析查询执行计划</li>
                        <li>根据查询模式设计合适的索引策略</li>
                    </ul>
                </div>
                
                <p>
                    通过实施这些优化措施，您可以确保 MySQL 索引的高效使用，从而提升数据库的整体性能和应用响应速度。
                </p>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-8">
        <div class="container mx-auto px-4">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold text-white mb-2">技术小馆</h3>
                    <p class="text-sm">专业的数据库技术分享平台</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-blue-300 hover:text-white transition-colors flex items-center" target="_blank">
                        <i class="fas fa-external-link-alt mr-2"></i>
                        http://www.yuque.com/jtostring
                    </a>
                </div>
            </div>
            <div class="mt-8 pt-6 border-t border-gray-800 text-center text-sm">
                <p>© 2024 技术小馆. All rights reserved.</p>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```